const express = require('express');
const router = express.Router();
const db = require('../config/db');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');

// 登录接口
router.post('/login', async (req, res) => {
  try {
    console.log('收到登录请求:', req.body);
    
    const { account, password, role } = req.body;

    // 参数验证
    if (!account || !password || !role) {
      console.log('登录参数缺失');
      return res.status(400).json({
        code: 400,
        message: '缺少必要参数'
      });
    }

    // 查询用户信息
    console.log(`查询用户: account=${account}, role=${role}`);
    const [rows] = await db.execute(
      'SELECT id, account, name, password, role FROM users WHERE account = ? AND role = ?',
      [account, role]
    );

    // 检查用户是否存在
    if (rows.length === 0) {
      console.log('用户不存在或角色不匹配');
      return res.status(401).json({
        code: 401,
        message: '账号或密码错误'
      });
    }

    const user = rows[0];
    console.log('找到用户:', user.account);

    // 验证密码
    console.log('验证密码...');
    const isPasswordValid = await bcrypt.compare(password, user.password);
    if (!isPasswordValid) {
      console.log('密码验证失败');
      return res.status(401).json({
        code: 401,
        message: '账号或密码错误'
      });
    }

    // 生成JWT令牌
    console.log('生成JWT令牌...');
    const token = jwt.sign(
      { id: user.id, account: user.account, name: user.name, role: user.role },
      process.env.JWT_SECRET,
      { expiresIn: process.env.JWT_EXPIRES_IN || '24h' }
    );

    // 返回成功响应（不返回密码）
    const userInfo = {
      id: user.id,
      account: user.account,
      name: user.name,
      role: user.role
    };

    console.log('登录成功:', user.account);
    res.json({
      code: 200,
      message: '登录成功',
      data: {
        ...userInfo,
        token: token
      }
    });
  } catch (error) {
    console.error('登录错误:', error);
    res.status(500).json({
      code: 500,
      message: '服务器内部错误: ' + error.message
    });
  }
});

// 获取用户信息接口
router.get('/user/info', async (req, res) => {
  try {
    console.log('收到获取用户信息请求');
    
    // 从请求头获取token
    const authHeader = req.headers.authorization;
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      console.log('未提供认证令牌');
      return res.status(401).json({
        code: 401,
        message: '未提供认证令牌'
      });
    }

    const token = authHeader.substring(7); // 移除 "Bearer " 前缀
    console.log('令牌:', token.substring(0, 20) + '...');

    // 验证token
    let decoded;
    try {
      decoded = jwt.verify(token, process.env.JWT_SECRET);
      console.log('令牌验证成功:', decoded.account);
    } catch (err) {
      console.log('令牌验证失败:', err.message);
      return res.status(401).json({
        code: 401,
        message: '无效的认证令牌'
      });
    }

    // 查询用户信息
    console.log('查询用户信息:', decoded.id);
    const [rows] = await db.execute(
      'SELECT id, account, name, role FROM users WHERE id = ?',
      [decoded.id]
    );

    if (rows.length === 0) {
      console.log('用户不存在');
      return res.status(404).json({
        code: 404,
        message: '用户不存在'
      });
    }

    const user = rows[0];
    console.log('返回用户信息:', user.account);

    res.json({
      code: 200,
      message: '获取用户信息成功',
      data: user
    });
  } catch (error) {
    console.error('获取用户信息错误:', error);
    res.status(500).json({
      code: 500,
      message: '服务器内部错误: ' + error.message
    });
  }
});

// 更新用户信息接口
router.put('/user/info', async (req, res) => {
  try {
    console.log('收到更新用户信息请求:', req.body);
    
    // 从请求头获取token
    const authHeader = req.headers.authorization;
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      console.log('未提供认证令牌');
      return res.status(401).json({
        code: 401,
        message: '未提供认证令牌'
      });
    }

    const token = authHeader.substring(7); // 移除 "Bearer " 前缀
    
    // 验证token
    let decoded;
    try {
      decoded = jwt.verify(token, process.env.JWT_SECRET);
      console.log('令牌验证成功:', decoded.account);
    } catch (err) {
      console.log('令牌验证失败:', err.message);
      return res.status(401).json({
        code: 401,
        message: '无效的认证令牌'
      });
    }

    // 获取更新的数据
    const { name } = req.body;
    
    // 参数验证
    if (!name) {
      return res.status(400).json({
        code: 400,
        message: '姓名不能为空'
      });
    }

    // 更新用户信息
    console.log('更新用户信息:', decoded.id);
    const [result] = await db.execute(
      'UPDATE users SET name = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
      [name, decoded.id]
    );

    if (result.affectedRows === 0) {
      console.log('用户不存在');
      return res.status(404).json({
        code: 404,
        message: '用户不存在'
      });
    }

    // 查询更新后的用户信息
    const [rows] = await db.execute(
      'SELECT id, account, name, role FROM users WHERE id = ?',
      [decoded.id]
    );

    const user = rows[0];
    console.log('用户信息更新成功:', user.account);

    res.json({
      code: 200,
      message: '用户信息更新成功',
      data: user
    });
  } catch (error) {
    console.error('更新用户信息错误:', error);
    res.status(500).json({
      code: 500,
      message: '服务器内部错误: ' + error.message
    });
  }
});

// 修改密码接口
router.put('/user/password', async (req, res) => {
  try {
    console.log('收到修改密码请求:', req.body);
    
    // 从请求头获取token
    const authHeader = req.headers.authorization;
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
      console.log('未提供认证令牌');
      return res.status(401).json({
        code: 401,
        message: '未提供认证令牌'
      });
    }

    const token = authHeader.substring(7); // 移除 "Bearer " 前缀
    
    // 验证token
    let decoded;
    try {
      decoded = jwt.verify(token, process.env.JWT_SECRET);
      console.log('令牌验证成功:', decoded.account);
    } catch (err) {
      console.log('令牌验证失败:', err.message);
      return res.status(401).json({
        code: 401,
        message: '无效的认证令牌'
      });
    }

    // 获取密码数据
    const { oldPassword, newPassword } = req.body;
    
    // 参数验证
    if (!oldPassword || !newPassword) {
      return res.status(400).json({
        code: 400,
        message: '旧密码和新密码不能为空'
      });
    }

    if (newPassword.length < 6) {
      return res.status(400).json({
        code: 400,
        message: '新密码长度不能少于6位'
      });
    }

    // 查询当前用户信息
    const [rows] = await db.execute(
      'SELECT id, account, password FROM users WHERE id = ?',
      [decoded.id]
    );

    if (rows.length === 0) {
      console.log('用户不存在');
      return res.status(404).json({
        code: 404,
        message: '用户不存在'
      });
    }

    const user = rows[0];
    
    // 验证旧密码
    console.log('验证旧密码...');
    const isOldPasswordValid = await bcrypt.compare(oldPassword, user.password);
    if (!isOldPasswordValid) {
      console.log('旧密码验证失败');
      return res.status(401).json({
        code: 401,
        message: '旧密码错误'
      });
    }

    // 生成新密码哈希
    console.log('生成新密码哈希...');
    const hashedPassword = await bcrypt.hash(newPassword, 10);

    // 更新密码
    console.log('更新密码:', user.account);
    const [result] = await db.execute(
      'UPDATE users SET password = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
      [hashedPassword, decoded.id]
    );

    if (result.affectedRows === 0) {
      console.log('更新密码失败');
      return res.status(500).json({
        code: 500,
        message: '更新密码失败'
      });
    }

    console.log('密码更新成功:', user.account);

    res.json({
      code: 200,
      message: '密码修改成功'
    });
  } catch (error) {
    console.error('修改密码错误:', error);
    res.status(500).json({
      code: 500,
      message: '服务器内部错误: ' + error.message
    });
  }
});

module.exports = router;